"""
removeprefix()
截取字符串，括号里填写需要去掉的字符

str()将数字转换成字符串

repr() 产生一个解释器易读的表达形式。

original = [1, 2, 3]
new_list = original[1:]  # 返回 [2, 3]，原列表不变      不删除原表数据，用切片方法



sort()
正序排序
sort(reverse=True)
相反排序

sorted(需要的排序的数组)
临时排序不会改变原来的顺序
sorted(需要的排序的数组, reverse=True)
相反排序




test = ['g', 'a', 'c']
循环打印
for item in test:
    print(item)

range(1, 5)
打印数
1～4
range(2, 11, 2)
第三个参数是自增为2
打印结果为
2, 4, 6, 8, 10

min(需要的数组)
最少值
max(需要的数组)
最大值
sum(需要的数组)
总值



test = ['a', 'b', 'c', 'd', 'f', 'g']
print(test[0:3])
打印a, b, c
print(test[:3])
打印a, b, c
后面一个参数是最后显示索引的数，打印出来是索引的数减去开始的数，就是需要打印的个数

test(200, 50)
这种跟数组格式一样的（除了数组是[]，这种是()
这种叫’元组‘ 和数组的区别就是元组不可修改里面的值，但可以重新定义）


test = (200, 50, 11, 22, 334, 55)
IF格式 if: elif: else:
for item in test:
    if
item == 50:
print('找到了')
else:
print('没找到')

arr = [1, 2, 4, 112] not in in 可以直接判断
test = 12
if test not in arr:
    print('不等于12')
else:
    print('等于12')






message = input("请填写数据")
input()
让用户输入文本
print("数据为:", message)

message = ''

while message != 'zhupeng':                while
循环
不等于zhupeng继续输入数据
message = input('请输入数据')
print(message)

remove('sss')
删除功能。必须传特定的，不能全删

split()
默认以空白为分隔符将字符串分拆成多个部分

reponses = {}

status = True

while status:
    name = input("\n你叫什么名字")
    test = input("你喜欢过周末吗")

    reponses[name] = test

    reprat = input("是否还有人需要参与进来吗(yes/no)")
    if reprat == 'no':
        status = False

for key, value in reponses.items():
    print(f"{key} 还有 {value}")


def test():              def


创建函数
print("简单的函数")

test()


def test(*names):     加 * 号可以预设多个参数

，传参的时候可以一个或多个
for item in names:
    print(item)

test('zhu', 'peng')


def test(age, names, **user_info):           **


    user_info，它用于收集任意数量的关键字实参。  双星是字典。单星（上面的）是数组
user_info['age'] = age
user_info['names'] = names
return user_info

iten = test('zhu', 'peng', san='other', si='si')
print(iten)

import moban

导入函数整个文件

moban.make(16, 'zhu')
moban.make(12, 'zhu', 'peng')

from moban import make

也可以直接导入函数文件里的某一个函数（moban为函数文件, make
为函数名称）

make(16, 'zhu')
make(12, 'zhu', 'peng')

from moban import make as test

也可以用as
将函数名改成任何名称。也可以改变模块名称

test(16, 'zhu')
test(12, 'zhu', 'peng')

from pizza import *

使用星号（ * ）运算符可让
Python
导入模块中的所有函数

from dog import Dog

导入类
from module_name import *

导入模块的所有类
from module_name import Dog

导入模块的Dog类

from random import randint

randint(1, 6)
1 - 6
的随机整数

from random import choice

choice(test)
它将一个列表或元组作为参数，并随机返回其中的一个元素
test = [1, 2, 3, 4]
test = (1, 2, 3, 4)
test1 = choice(test)
print(test1)

from pathlib import Path

读取文件写法

path = Path('test.txt')
contents = path.read_text()
print(contents)

path = Path('text_files/test.txt')
相对路径
指的是text_files文件夹里的test.txt
文件

path = Path('/home/eric/data_files/ttext_files/test.txt')
绝对路径
指的是text_files文件夹里的test.txt
文件

from pathlib import Path

splitlines()  （用于‌按行分割字符串）将冗长的字符串转换为一系列行, 也就是转换成数组，它会智能识别不同操作系统中的换行符（如 \n、\r、\r\n
等），并支持是否保留行尾的换行符

path = Path('text_files/test.txt')
contents = path.read_text()
encoding = 'utf-8'
lines = contents.splitlines()

from pathlib import Path

write_text()
写入单行

path = Path('text_files/test.txt')
contents = path.write_text('zhjupeng')



else:
    # 计算文件大小包含多少个单词
    words = contents.split()
    num_word = len(words)
    print(f" {path}===>{num_word}")

from pathlib import Path

json.dumps()
将json格式的数据转换成字符串才能存到json文件里
import json

numbers = [1, 2, 3, 4]

path = Path('text_files/number.json')
contents = json.dumps(numbers)
path.write_text(contents)

from pathlib import Path

json.loads()
将一个
JSON
格式的字符串作为参数，并返回一个
Python
对象
import json

path = Path('text_files/number.json')
contents = path.read_text()
number = json.loads(contents)
print(number)

test = [1, 2, 3, 4, 5]
推导式
arr = []
test2 = [item for item in test if item % 2 == 0]
print(test2)




计算表示式  eval（）
x=10
y=20

numbers=eval("x+y")

print(numbers)


numbers=eval('{"name":"zhangsan","age":20}["age"]')

print(numbers)  打印出为20 （age的key值）


join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
s1 = "-"
s2 = ""
seq = ("n", "o", "w", "c", "o", "d", "e", "r") # 字符串序列
print (s1.join( seq ))
print (s2.join( seq ))
"""



"""列表

 del() 删除
list = ['Google', 'Nowcoder', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

列表函数&方法
1	len(list) 列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort( key=None, reverse=False) 对原列表进行排序
10	list.clear() 清空列表
11	list.copy() 复制列表


遍历时，索引位置和对应值可以使用 enumerate() 函数
knights =['tic', 'tac', 'toe']
for k, v in enumerate(knights):
  print(k, v)


同时遍历两个或更多的序列，可以使用 zip() 组合
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
   print('What is your {0}?  It is {1}.'.format(q, a))  

"""

"""元组

del() 删除 
tup = ('Google', 'Nowcoder', 1997, 2000)
print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)
tuple(seq) 将列表转换为元组。
"""

"""字典 https://www.nowcoder.com/tutorial/10005/f9a1fa805b604d0dbddcb8835286d8cb
dict = {'Name': 'Nowcoder', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

字典内置函数&方法 
str(dict) 输出字典，以可打印的字符串表示
type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

1	radiansdict.clear() 删除字典内所有元素
2	radiansdict.copy() 返回一个字典的浅复制
3	radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5	key in dict 如果键在字典dict里返回true，否则返回false
6	radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
7	radiansdict.keys() 返回一个迭代器，可以使用 list() 来转换为列表
8	radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10	radiansdict.values() 返回一个迭代器，可以使用 list() 来转换为列表
11	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem() 随机返回并删除字典中的最后一对键和值。


for key, value in arr.items():         items()
获取所有集合所有键和值
print(f"\n{key}")
print(f"\n{value}")

for key in arr.keys():              keys()
获取所有集合所有键
print(f"\n{key}")

for key in arr:                    也可以这样获取所有集合所有键
print(f"\n{key}")

if 'name' in arr.keys():              keys()
也这样用来判断
print('在')
else:
print('不在')

for item in arr.values():        values()
获取所有集合所有值

for item in set(arr.values()):          set()
删除重复的值
print(item)


"""

"""集合 https://www.nowcoder.com/tutorial/10005/73e415374e76426aa3e7f0a3097342aa


集合

s={'a','b','c'}
s.discard('a')   删除，没有找到的不报错
s.remove('v')    删除，没有找到的会报错
s.update({'r','f'})  修改，可以修改任意
s.add({'r','f'})
s.add('c')      添加，不能添加元组，集合，字典
print(s)

集合，交集
s1={'a','b','c'}
s2={'v','b','f'}
test=s1 & s2
print(test)
也可以用test=s1.intersection(s2)      intersection()  交集的函数方法


集合，并集

s1={'a','b','c'}
s2={'v','b','f'}
s3={'v','b','f'}
test=s1 | s2

print(test)
也可以用test=s1.union(s2)  test=s1.union(s2，s3)      union（） 并集的函数


thisset = set(("Google", "Nowcoder", "Taobao"))
thisset.add("Facebook")      添加元素
thisset.remove( x )         移除元素
thisset.clear()             清空

集合内置方法完整列表
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

"""

"""
    字符串内建函数  https://www.nowcoder.com/tutorial/10005/3b0a198d1f1044029dfc879916077f51
1   capitalize() 将字符串的第一个字符转换为大写
2	center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3	count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4	bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5	encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
6	endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7	expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8	find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9	index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常.
10	isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
11	isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12	isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
13	islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14	isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
15	isspace() 如果字符串中只包含空白，则返回 True，否则返回 False.
16	istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False
17	isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18	join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19	len(string) 返回字符串长度
20	ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21	lower() 转换字符串中所有大写字符为小写.
22	lstrip() 截掉字符串左边的空格或指定字符。
23	maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24	max(str) 返回字符串 str 中最大的字母。
25	min(str) 返回字符串 str 中最小的字母。
26	replace(old, new [, max]) 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
27	rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找.
28	rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.
29	rjust(width,[, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30	rstrip() 删除字符串字符串末尾的空格.
31	split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
32	splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33	startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34	strip([chars]) 在字符串上执行 lstrip()和 rstrip()
35	swapcase() 将字符串中大写转换为小写，小写转换为大写
36	title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37	translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38	upper() 转换字符串中的小写字母为大写
39	zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0
40	isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

"""

"""迭代器与生成器
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
print (next(it))   # 输出迭代器的下一个元素

print (next(it))
print (next(it))


def fibonacci(n):  # 生成器函数 -
   a, b, counter = 0, 1, 0
   while True:
      if (counter > n):
         return
      yield a
      a, b = b, a + b
      counter += 1


f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成

while True:
   try:
      print(next(f), end=" ")    f值是a的值
   except StopIteration:
      sys.exit()

"""


"""函数
lambda 函数的语法只包含一个语句，lambda [arg1 [,arg2,.....argn]]:expression
 
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))


def printinfo( arg1, *vartuple ):    函数参数 *变量=>以元组(tuple)的形式导入   
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )



def printinfo( arg1, *vartuple ):   **变量名 参数会以字典的形式导入 a=2,b=3
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

"""


"""数据结构
list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i])	从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x)	返回 x 在列表中出现的次数。
list.sort()	对列表中的元素进行排序。
list.reverse()	倒排列表中的元素。
list.copy()	返回列表的浅复制，等于a[:]。


列表推导式
test = [value * 2 for value in range(1, 11)]
列表推导式
打印出来
2, 4, 6, 8, 10, 12, 14, 16, 18, 20


‌按值删除‌：remove()（列表、集合）、replace()（字符串）；
‌按索引/键删除‌：pop()（列表、字典）、del 语句；
‌清空数据‌：clear()（列表、字典）。

"""



"""读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode)
filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

不同模式打开文件的完全列表:
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。


# 打开一个文件
f = open("/tmp/foo.txt", "w")
 
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
 
# 关闭打开的文件
f.close()
第一个参数为要打开的文件名。
第二个参数描述文件如何使用的字符。 mode 可以是 'r' 如果文件只读, 'w' 只用于写 (如果存在同名文件则将被删除), 和 'a' 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. 'r+' 同时用于读写。 mode 参数是可选的; 'r' 将是默认值。


文件对象的方法
f.read()     读取一个文件的内容

f.readline()    从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

f.readlines()   返回该文件中包含的所有行

f.write()       将 string 写入到文件中, 然后返回写入的字符数。

f.tell()        返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

f.seek()        如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。
seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ： 表示从当前位置往后移动x个字符
seek(-x,2)：表示从文件的结尾往前移动x个字符
from_what 值为默认为0，即文件开头。下面给出一个完整的例子：
>>> f = open('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'


f.close()       关闭打开的文件

"""


"""File(文件) 方法
open(file, mode='r') 
  
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:

mode 参数有：
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（Python 3 不支持）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：
1	file.close()关闭文件。关闭后文件不能再进行读写操作。
2	file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4	file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next() 返回文件下一行。（Python 3 中的 File 对象不支持 next() 方法）
6	file.read([size])从文件读取指定的字节数，如果未给定或为负则读取所有。
7	file.readline([size])读取整行，包括 "\n" 字符。
8	file.readlines([sizeint])读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9	file.seek(offset[, whence])设置文件当前位置
10	file.tell()返回文件当前位置。
11	file.truncate([size])从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。
12	file.write(str)将字符串写入文件，返回的是写入的字符长度。
13	file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
"""

"""OS 文件及目录方法 https://www.nowcoder.com/tutorial/10005/709219b6a7ca4739a44745b2e65bd74f

1	os.access(path, mode) 检验权限模式
2	os.chdir(path) 改变当前工作目录
3	os.chflags(path, flags) 设置路径的标记为数字标记。
4	os.chmod(path, mode) 更改权限
5	os.chown(path, uid, gid) 更改文件所有者
6	os.chroot(path) 改变当前进程的根目录
7	os.close(fd) 关闭文件描述符 fd
8	os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9	os.dup(fd) 复制文件描述符 fd
10	os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
11	os.fchdir(fd) 通过文件描述符改变当前工作目录
12	os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13	os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14	os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15	os.fdopen(fd[, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16	os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17	os.fstat(fd) 返回文件描述符fd的状态，像stat()。
18	os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19	os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。
20	os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21	os.getcwd() 返回当前工作目录
22	os.getcwdu() 返回一个当前工作目录的Unicode对象
23	os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24	os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25	os.lchmod(path, mode) 修改连接文件权限
26	os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
27	os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
28	os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
29	os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30	os.lstat(path) 像stat(),但是没有软链接
31	os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32	os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
33	os.makedirs(path[, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34	os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35	os.mkdir(path[, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36	os.mkfifo(path[, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制)
37	os.mknod(filename[, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38	os.open(file, flags[, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
39	os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40	os.pathconf(path, name) 返回相关文件的系统配置信息。
41	os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42	os.popen(command[, mode[, bufsize]]) 从一个 command 打开一个管道
43	os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44	os.readlink(path) 返回软链接所指向的文件
45	os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46	os.removedirs(path) 递归删除目录。
47	os.rename(src, dst) 重命名文件或目录，从 src 到 dst
48	os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
49	os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50	os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51	os.stat_float_times([newvalue]) 决定stat_result是否以float对象显示时间戳
52	os.statvfs(path) 获取指定路径的文件系统统计信息
53	os.symlink(src, dst) 创建一个软链接
54	os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55	os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56	os.tempnam([dir[, prefix]]) Python3 中已删除。返回唯一的路径名用于创建临时文件。
57	os.tmpfile() Python3 中已删除。返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58	os.tmpnam() Python3 中已删除。为创建一个临时文件返回一个唯一的路径
59	os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
60	os.unlink(path) 删除文件路径
61	os.utime(path, times) 返回指定的path文件的访问和修改的时间。
62	os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。
63	os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
64	os.path 模块 获取文件的属性信息。
"""


"""错误和异常

ZeroDivisionError  异常

FileNotFoundError   文件异常类

from pathlib import Path

path = Path("text_files/test.txt")
try:
    contents = path.read_text(encoding='utf-8')
except FileNotFoundError:
    print("文件不存在");
    pass   也可以用pass发生异常但不报错
    raise   抛出异常
   
"""



"""面向对象
类的专有方法：
init : 构造函数，在生成对象时调用
del : 析构函数，释放对象时使用
repr : 打印，转换
setitem : 按照索引赋值
getitem: 按照索引获取值
len: 获得长度
cmp: 比较运算
call: 函数调用
add: 加运算
sub: 减运算
mul: 乘运算
truediv: 除运算
mod: 求余运算
pow: 乘方

"""


